import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;


public class Grafo {
	private int cantVertices;
	private int matAdy[][];
	private int grados[]; //Guardo para cada numero de grado, la cantidad de vertices que tiene.
	private int vertices[]; //Guardo para cada vertice, el grado que tiene.
	private int maximoVertice=0;
	
	public Grafo(int m) {
		cantVertices = m;
		matAdy = new int[cantVertices][cantVertices];
		vertices = new int[cantVertices];
		grados = new int[cantVertices]; //Los grados de un grafo con n nodos a lo sumo pueden ser n-1.
		
		for(int y=0; y<cantVertices; y++)
			for(int x=0; x<cantVertices; x++)
				matAdy[x][y] = 0;
	}
	
	public int getCantVertices() {
		return cantVertices;
	}
	
	public void setCantVertices(int cantVertices) {
		this.cantVertices = cantVertices;
	}
	
	public int[][] getMatAdy() {
		return matAdy;
	}
	
	public void setMatAdy(int[][] matAdy) {
		this.matAdy = matAdy;
	}
	
	public int[] getGrados() {
		return grados;
	}
	
	public void setGrados(int[] grados) {
		this.grados = grados;
	}
	
	public int[] getVertices() {
		return vertices;
	}
	
	public void setVertices(int[] vertices) {
		this.vertices = vertices;
	}
	
	public void agregaEje(int i, int f) {
		matAdy[i-1][f-1] = 1;
		matAdy[f-1][i-1] = 1;
	}
	
	public boolean estaRelacionado(int i, int f) {
		if (matAdy[i-1][f-1] == 1)
			return true;
		else
			return false;
	}
	
	public Set<Integer> obtengoVecinos(int u) {
		Set<Integer> res = new HashSet<Integer>();
		
		for(int j=1; j<=cantVertices; j++) {
			if(estaRelacionado(u, j))
				res.add(j);
		}
		
		return res;
	}
	
	public Set<Integer> obtengoVecinos(Set<Integer> conjunto) {
		Set<Integer> res = new HashSet<Integer>();
		Iterator<Integer> it = conjunto.iterator();
		
		while (it.hasNext()) {
			res.addAll(obtengoVecinos(it.next()));
		}
		
		res.removeAll(conjunto);
		
		return res;
	}
	
	
	
	
	
	
	
	public void setVectorGrados(){
		for (int i =0 ; i < cantVertices;i++){
			grados[vertices[i]]++;
		}
		for (int i =cantVertices-2 ; i > 0 ;i--){
			grados[i-1] += grados[i];
		}		
	}
	
	public int getVectorGrados(int i){
		return this.grados[i-1];
	}
	
	public void setVectorVertices(int i,int grado){
		this.vertices[i-1]=grado;
	}
	
	public int getVectorVertices(int i){
		return this.vertices[i-1];
	}
	
	public int getVerticeMaximo(Set<Integer> c) {
		Iterator<Integer> it = c.iterator();
		Integer u = it.next();
		int maximo=u;
		while (it.hasNext()){
			u = it.next();
			if (vertices[maximo-1]<vertices[u-1]){
				maximo=u;
			}
		}
		return maximo;
	}
	public int getVerticeMinimo(Set<Integer> c) {
		Iterator<Integer> it = c.iterator();
		Integer u = it.next();
		int minimo=u;
		if (c.size()>1){
			while (it.hasNext()){
				u = it.next();
				if (vertices[minimo-1]>vertices[u-1]){
					minimo=u;
				}
			}
		}
		return minimo;
	}
	
	
	public int getVerticeMaximo() {
		return maximoVertice;
	}
	
	public void setMaximoVertice(int maximoVertice) {
		this.maximoVertice = maximoVertice;
	}
	
/*	public int getVerticeMaximo(){
		int maximo=0;
		for (int i =0 ; i < cantVertices;i++){
			if (vertices[maximo]<vertices[i]){
				maximo=i;
			}
		}
	return maximo;
	}
*/	

}
